package org.ycb.ycbisgod.ycbwoxihuanni.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.ycb.ycbisgod.ycbwoxihuanni.entity.Node;
import org.ycb.ycbisgod.ycbwoxihuanni.service.INodeService;
import org.ycb.ycbisgod.ycbwoxihuanni.util.Result;
import org.ycb.ycbisgod.ycbwoxihuanni.constant.MessageConstant;


import java.util.List;

@Slf4j
@RestController
@RequestMapping("/node")
public class NodeController {
    @Autowired
    private INodeService nodeService;

    @RequestMapping("/list")
    public Result list() {
        List<Node> list = nodeService.list();
        return new Result(true, MessageConstant.NODE_QUERY_SUCCESS, list);
    }
    @RequestMapping("/add")
    public Result add(@RequestBody Node node) {
        try {
            log.info("添加节点：{}", node);
            nodeService.save(node);
            return new Result(true, MessageConstant.NODE_ADD_SUCCESS);
        }catch (Exception e){
            log.error("添加失败: {}", e.getMessage());
            return new Result(false, MessageConstant.NODE_ADD_FAIL);
        }
    }
    @RequestMapping("/findOwner")
    public Result findOwner(Integer ownerId) {
        try {
            log.info("查询节点：{}", ownerId);
            Node node = nodeService.findByOwnerId(ownerId);
            return new Result(true, MessageConstant.NODE_FIND_SUCCESS, node);
        }catch (Exception e){
            log.error("查询失败: {}", e.getMessage());
            return new Result(false, MessageConstant.NODE_FIND_FAIL);
        }
    }

    /**
     * 获取指定节点的所有子节点
     * GET /node/{nodeId}/children
     */
    @RequestMapping("/{nodeId}/children")
    public Result getNodeChildren(@PathVariable Integer nodeId) {
        try {
            List<Node> children = nodeService.getChildren(nodeId);
            return new Result(true, MessageConstant.NODE_GET_NODE_CHILDREN_SUCCESS, children);
        } catch (Exception e) {
            log.error("获取节点[{}]子节点失败：", nodeId, e);
            return new Result(false, MessageConstant.NODE_GET_NODE_CHILDREN_FAIL + ": " + e.getMessage(), null);
        }
    }

    /**
     * 添加两个已存在节点之间的子节点关系。
     * POST /node/{nodeId}/addNextNodeConnect/{nextnodeId}
     * TODO:验证两个节点是否至少有其一是自己的节点
     */
    @RequestMapping("/{nodeId}/addNextNodeConnect/{nextnodeId}")
    public Result addNextNodeConnect(@PathVariable Integer nodeId, @PathVariable Integer nextnodeId) {
        try {
            boolean success = nodeService.addNextNodeConnect(nodeId, nextnodeId);
            if (success) {
                return new Result(true, MessageConstant.NODE_ADD_NEXT_NODE_SUCCESS, null);
            } else {
                // 根据 addNextNodeConnect 的内部逻辑，返回 false 可能的原因：
                // 1. 父节点或子节点不存在
                // 2. 关系已存在
                // 3. 形成环状结构
                // 为了更具体的错误消息，可以考虑在 Service 层抛出特定异常并在 Controller 层捕获
                if (nodeService.findByOwnerId(nodeId) == null || nodeService.findByOwnerId(nextnodeId) == null) {
                    return new Result(false, MessageConstant.NODE_NOT_FOUND, null);
                }
                // 这里需要改进，如果Service层能抛出特定异常，会更好
                // 暂时用一个通用消息
                return new Result(false, MessageConstant.NODE_ADD_NEXT_NODE_FAIL + ": 检查节点是否存在、关系是否重复或是否会形成环状结构", null);
            }
        } catch (Exception e) {
            log.error("添加节点[{}]的子节点[{}]关系失败：", nodeId, nextnodeId, e);
            // 捕获到 Service 层可能抛出的 RuntimeException，例如环状结构异常
            if (e.getMessage() != null && e.getMessage().contains(MessageConstant.NODE_CYCLE_DETECTED)) {
                return new Result(false, MessageConstant.NODE_CYCLE_DETECTED, null);
            }
            return new Result(false, MessageConstant.NODE_ADD_NEXT_NODE_FAIL + ": " + e.getMessage(), null);
        }
    }

    /**
     * 创建一个新节点并将其作为指定节点的子节点。
     * POST /node/{parentNodeId}/addNextNode
     * 请求体中包含新子节点的数据。
     */
    @RequestMapping("/{parentNodeId}/addNextNode")
    public Result addNextNode(@PathVariable Integer parentNodeId, @RequestBody Node newChildNode) {
        try {
            log.info("为父节点[{}]添加新子节点：{}", parentNodeId, newChildNode);
            boolean success = nodeService.addNextNode(parentNodeId, newChildNode);
            if (success) {
                return new Result(true, MessageConstant.NODE_ADD_SUCCESS + "并建立关系", newChildNode); // 返回新创建的节点信息
            } else {
                // 失败原因可能包括：父节点不存在、子节点数据无效、或建立关系失败（如环状结构、重复关系）
                // 同样，这里可以通过Service层抛出更具体的异常来返回更精确的错误消息
                return new Result(false, MessageConstant.NODE_ADD_FAIL + "或建立关系失败", null);
            }
        } catch (Exception e) {
            log.error("为父节点[{}]添加新子节点失败：", parentNodeId, e);
            if (e.getMessage() != null && e.getMessage().contains(MessageConstant.NODE_CYCLE_DETECTED)) {
                return new Result(false, MessageConstant.NODE_CYCLE_DETECTED, null);
            }
            return new Result(false, MessageConstant.NODE_ADD_FAIL + ": " + e.getMessage(), null);
        }
    }

    /**
     * 删除子节点关系
     * DELETE /node/{nodeId}/removeNextNode/{nextnodeId}
     * TODO:这里仅仅只是删除两个节点中的关系，不会删除节点，因此缺少级联删除节点的逻辑
     */
    @RequestMapping("/{nodeId}/removeNextNode/{nextnodeId}")
    public Result removeNextNode(@PathVariable Integer nodeId, @PathVariable Integer nextnodeId) {
        try {
            boolean success = nodeService.removeNextNode(nodeId, nextnodeId);
            if (success) {
                return new Result(true, MessageConstant.NODE_REMOVE_NEXT_NODE_SUCCESS, null);
            } else {
                return new Result(false, MessageConstant.NODE_REMOVE_NEXT_NODE_FAIL + ": Relationship not found or unknown error", null);
            }
        } catch (Exception e) {
            log.error("删除节点[{}]的子节点[{}]关系失败：", nodeId, nextnodeId, e);
            return new Result(false, MessageConstant.NODE_REMOVE_NEXT_NODE_FAIL + ": " + e.getMessage(), null);
        }
    }
}
